/*
The MIT License (MIT)
Copyright (c) 2013 Dalvik Boss dalvikboss@gmail.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
// $ANTLR 3.4 C:\\devel\\sidl\\sidl\\grammer\\Sidl.g 2013-01-30 15:26:24
package sidl;

import org.antlr.runtime.BaseRecognizer;
import org.antlr.runtime.CharStream;
import org.antlr.runtime.DFA;
import org.antlr.runtime.EarlyExitException;
import org.antlr.runtime.Lexer;
import org.antlr.runtime.MismatchedSetException;
import org.antlr.runtime.NoViableAltException;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.RecognizerSharedState;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class SidlLexer extends Lexer {
    public static final int EOF=-1;
    public static final int T__15=15;
    public static final int T__16=16;
    public static final int T__17=17;
    public static final int T__18=18;
    public static final int T__19=19;
    public static final int T__20=20;
    public static final int T__21=21;
    public static final int T__22=22;
    public static final int T__23=23;
    public static final int T__24=24;
    public static final int T__25=25;
    public static final int T__26=26;
    public static final int T__27=27;
    public static final int T__28=28;
    public static final int T__29=29;
    public static final int T__30=30;
    public static final int T__31=31;
    public static final int T__32=32;
    public static final int T__33=33;
    public static final int CHAR=4;
    public static final int COMMENT=5;
    public static final int ESC_SEQ=6;
    public static final int HEXINT=7;
    public static final int HEX_DIGIT=8;
    public static final int IDT=9;
    public static final int INT=10;
    public static final int OCTAL_ESC=11;
    public static final int STRING=12;
    public static final int UNICODE_ESC=13;
    public static final int WS=14;

    // delegates
    // delegators
    public Lexer[] getDelegates() {
        return new Lexer[] {};
    }

    public SidlLexer() {} 
    public SidlLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public SidlLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);
    }
    public String getGrammarFileName() { return "C:\\devel\\sidl\\sidl\\grammer\\Sidl.g"; }

    // $ANTLR start "T__15"
    public final void mT__15() throws RecognitionException {
        try {
            int _type = T__15;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:4:7: ( '(' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:4:9: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__15"

    // $ANTLR start "T__16"
    public final void mT__16() throws RecognitionException {
        try {
            int _type = T__16;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:5:7: ( ')' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:5:9: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__16"

    // $ANTLR start "T__17"
    public final void mT__17() throws RecognitionException {
        try {
            int _type = T__17;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:6:7: ( '*' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:6:9: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__17"

    // $ANTLR start "T__18"
    public final void mT__18() throws RecognitionException {
        try {
            int _type = T__18;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:7:7: ( ',' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:7:9: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__18"

    // $ANTLR start "T__19"
    public final void mT__19() throws RecognitionException {
        try {
            int _type = T__19;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:8:7: ( '.' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:8:9: '.'
            {
            match('.'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__19"

    // $ANTLR start "T__20"
    public final void mT__20() throws RecognitionException {
        try {
            int _type = T__20;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:9:7: ( ';' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:9:9: ';'
            {
            match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__20"

    // $ANTLR start "T__21"
    public final void mT__21() throws RecognitionException {
        try {
            int _type = T__21;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:10:7: ( '=' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:10:9: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__21"

    // $ANTLR start "T__22"
    public final void mT__22() throws RecognitionException {
        try {
            int _type = T__22;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:11:7: ( '@options' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:11:9: '@options'
            {
            match("@options"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__22"

    // $ANTLR start "T__23"
    public final void mT__23() throws RecognitionException {
        try {
            int _type = T__23;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:12:7: ( '[' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:12:9: '['
            {
            match('['); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__23"

    // $ANTLR start "T__24"
    public final void mT__24() throws RecognitionException {
        try {
            int _type = T__24;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:13:7: ( ']' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:13:9: ']'
            {
            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__24"

    // $ANTLR start "T__25"
    public final void mT__25() throws RecognitionException {
        try {
            int _type = T__25;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:14:7: ( 'class' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:14:9: 'class'
            {
            match("class"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__25"

    // $ANTLR start "T__26"
    public final void mT__26() throws RecognitionException {
        try {
            int _type = T__26;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:15:7: ( 'const' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:15:9: 'const'
            {
            match("const"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__26"

    // $ANTLR start "T__27"
    public final void mT__27() throws RecognitionException {
        try {
            int _type = T__27;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:16:7: ( 'import' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:16:9: 'import'
            {
            match("import"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__27"

    // $ANTLR start "T__28"
    public final void mT__28() throws RecognitionException {
        try {
            int _type = T__28;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:17:7: ( 'interface' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:17:9: 'interface'
            {
            match("interface"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__28"

    // $ANTLR start "T__29"
    public final void mT__29() throws RecognitionException {
        try {
            int _type = T__29;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:18:7: ( 'out' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:18:9: 'out'
            {
            match("out"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__29"

    // $ANTLR start "T__30"
    public final void mT__30() throws RecognitionException {
        try {
            int _type = T__30;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:19:7: ( 'package' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:19:9: 'package'
            {
            match("package"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__30"

    // $ANTLR start "T__31"
    public final void mT__31() throws RecognitionException {
        try {
            int _type = T__31;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:20:7: ( 'void' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:20:9: 'void'
            {
            match("void"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__31"

    // $ANTLR start "T__32"
    public final void mT__32() throws RecognitionException {
        try {
            int _type = T__32;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:21:7: ( '{' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:21:9: '{'
            {
            match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__32"

    // $ANTLR start "T__33"
    public final void mT__33() throws RecognitionException {
        try {
            int _type = T__33;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:22:7: ( '}' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:22:9: '}'
            {
            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__33"

    // $ANTLR start "IDT"
    public final void mIDT() throws RecognitionException {
        try {
            int _type = IDT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:25:6: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:25:8: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            {
            if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:25:32: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( ((LA1_0 >= '0' && LA1_0 <= '9')||(LA1_0 >= 'A' && LA1_0 <= 'Z')||LA1_0=='_'||(LA1_0 >= 'a' && LA1_0 <= 'z')) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IDT"

    // $ANTLR start "INT"
    public final void mINT() throws RecognitionException {
        try {
            int _type = INT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:29:5: ( ( '0' .. '9' )+ )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:29:7: ( '0' .. '9' )+
            {
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:29:7: ( '0' .. '9' )+
            int cnt2=0;
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( ((LA2_0 >= '0' && LA2_0 <= '9')) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt2 >= 1 ) break loop2;
                        EarlyExitException eee =
                            new EarlyExitException(2, input);
                        throw eee;
                }
                cnt2++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "INT"

    // $ANTLR start "COMMENT"
    public final void mCOMMENT() throws RecognitionException {
        try {
            int _type = COMMENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:33:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | '/*' ( options {greedy=false; } : . )* '*/' )
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0=='/') ) {
                int LA6_1 = input.LA(2);

                if ( (LA6_1=='/') ) {
                    alt6=1;
                }
                else if ( (LA6_1=='*') ) {
                    alt6=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 6, 1, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;

            }
            switch (alt6) {
                case 1 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:33:9: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
                    {
                    match("//"); 



                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:33:14: (~ ( '\\n' | '\\r' ) )*
                    loop3:
                    do {
                        int alt3=2;
                        int LA3_0 = input.LA(1);

                        if ( ((LA3_0 >= '\u0000' && LA3_0 <= '\t')||(LA3_0 >= '\u000B' && LA3_0 <= '\f')||(LA3_0 >= '\u000E' && LA3_0 <= '\uFFFF')) ) {
                            alt3=1;
                        }


                        switch (alt3) {
                    	case 1 :
                    	    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:
                    	    {
                    	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop3;
                        }
                    } while (true);


                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:33:28: ( '\\r' )?
                    int alt4=2;
                    int LA4_0 = input.LA(1);

                    if ( (LA4_0=='\r') ) {
                        alt4=1;
                    }
                    switch (alt4) {
                        case 1 :
                            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:33:28: '\\r'
                            {
                            match('\r'); 

                            }
                            break;

                    }


                    match('\n'); 

                    _channel=HIDDEN;

                    }
                    break;
                case 2 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:34:9: '/*' ( options {greedy=false; } : . )* '*/'
                    {
                    match("/*"); 



                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:34:14: ( options {greedy=false; } : . )*
                    loop5:
                    do {
                        int alt5=2;
                        int LA5_0 = input.LA(1);

                        if ( (LA5_0=='*') ) {
                            int LA5_1 = input.LA(2);

                            if ( (LA5_1=='/') ) {
                                alt5=2;
                            }
                            else if ( ((LA5_1 >= '\u0000' && LA5_1 <= '.')||(LA5_1 >= '0' && LA5_1 <= '\uFFFF')) ) {
                                alt5=1;
                            }


                        }
                        else if ( ((LA5_0 >= '\u0000' && LA5_0 <= ')')||(LA5_0 >= '+' && LA5_0 <= '\uFFFF')) ) {
                            alt5=1;
                        }


                        switch (alt5) {
                    	case 1 :
                    	    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:34:42: .
                    	    {
                    	    matchAny(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop5;
                        }
                    } while (true);


                    match("*/"); 



                    _channel=HIDDEN;

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMMENT"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:37:5: ( ( ' ' | '\\t' | '\\r' | '\\n' ) )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:37:9: ( ' ' | '\\t' | '\\r' | '\\n' )
            {
            if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            _channel=HIDDEN;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "WS"

    // $ANTLR start "STRING"
    public final void mSTRING() throws RecognitionException {
        try {
            int _type = STRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:45:5: ( '\"' ( ESC_SEQ |~ ( '\\\\' | '\"' ) )* '\"' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:45:8: '\"' ( ESC_SEQ |~ ( '\\\\' | '\"' ) )* '\"'
            {
            match('\"'); 

            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:45:12: ( ESC_SEQ |~ ( '\\\\' | '\"' ) )*
            loop7:
            do {
                int alt7=3;
                int LA7_0 = input.LA(1);

                if ( (LA7_0=='\\') ) {
                    alt7=1;
                }
                else if ( ((LA7_0 >= '\u0000' && LA7_0 <= '!')||(LA7_0 >= '#' && LA7_0 <= '[')||(LA7_0 >= ']' && LA7_0 <= '\uFFFF')) ) {
                    alt7=2;
                }


                switch (alt7) {
            	case 1 :
            	    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:45:14: ESC_SEQ
            	    {
            	    mESC_SEQ(); 


            	    }
            	    break;
            	case 2 :
            	    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:45:24: ~ ( '\\\\' | '\"' )
            	    {
            	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop7;
                }
            } while (true);


            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "STRING"

    // $ANTLR start "CHAR"
    public final void mCHAR() throws RecognitionException {
        try {
            int _type = CHAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:48:5: ( '\\'' ( ESC_SEQ |~ ( '\\'' | '\\\\' ) ) '\\'' )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:48:8: '\\'' ( ESC_SEQ |~ ( '\\'' | '\\\\' ) ) '\\''
            {
            match('\''); 

            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:48:13: ( ESC_SEQ |~ ( '\\'' | '\\\\' ) )
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0=='\\') ) {
                alt8=1;
            }
            else if ( ((LA8_0 >= '\u0000' && LA8_0 <= '&')||(LA8_0 >= '(' && LA8_0 <= '[')||(LA8_0 >= ']' && LA8_0 <= '\uFFFF')) ) {
                alt8=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;

            }
            switch (alt8) {
                case 1 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:48:15: ESC_SEQ
                    {
                    mESC_SEQ(); 


                    }
                    break;
                case 2 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:48:25: ~ ( '\\'' | '\\\\' )
                    {
                    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '&')||(input.LA(1) >= '(' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;

            }


            match('\''); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CHAR"

    // $ANTLR start "HEX_DIGIT"
    public final void mHEX_DIGIT() throws RecognitionException {
        try {
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:53:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:
            {
            if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'F')||(input.LA(1) >= 'a' && input.LA(1) <= 'f') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "HEX_DIGIT"

    // $ANTLR start "ESC_SEQ"
    public final void mESC_SEQ() throws RecognitionException {
        try {
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:57:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UNICODE_ESC | OCTAL_ESC )
            int alt9=3;
            int LA9_0 = input.LA(1);

            if ( (LA9_0=='\\') ) {
                switch ( input.LA(2) ) {
                case '\"':
                case '\'':
                case '\\':
                case 'b':
                case 'f':
                case 'n':
                case 'r':
                case 't':
                    {
                    alt9=1;
                    }
                    break;
                case 'u':
                    {
                    alt9=2;
                    }
                    break;
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                    {
                    alt9=3;
                    }
                    break;
                default:
                    NoViableAltException nvae =
                        new NoViableAltException("", 9, 1, input);

                    throw nvae;

                }

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;

            }
            switch (alt9) {
                case 1 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:57:9: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
                    {
                    match('\\'); 

                    if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||input.LA(1)=='t' ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;
                case 2 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:58:9: UNICODE_ESC
                    {
                    mUNICODE_ESC(); 


                    }
                    break;
                case 3 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:59:9: OCTAL_ESC
                    {
                    mOCTAL_ESC(); 


                    }
                    break;

            }

        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ESC_SEQ"

    // $ANTLR start "OCTAL_ESC"
    public final void mOCTAL_ESC() throws RecognitionException {
        try {
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:64:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )
            int alt10=3;
            int LA10_0 = input.LA(1);

            if ( (LA10_0=='\\') ) {
                int LA10_1 = input.LA(2);

                if ( ((LA10_1 >= '0' && LA10_1 <= '3')) ) {
                    int LA10_2 = input.LA(3);

                    if ( ((LA10_2 >= '0' && LA10_2 <= '7')) ) {
                        int LA10_4 = input.LA(4);

                        if ( ((LA10_4 >= '0' && LA10_4 <= '7')) ) {
                            alt10=1;
                        }
                        else {
                            alt10=2;
                        }
                    }
                    else {
                        alt10=3;
                    }
                }
                else if ( ((LA10_1 >= '4' && LA10_1 <= '7')) ) {
                    int LA10_3 = input.LA(3);

                    if ( ((LA10_3 >= '0' && LA10_3 <= '7')) ) {
                        alt10=2;
                    }
                    else {
                        alt10=3;
                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 10, 1, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;

            }
            switch (alt10) {
                case 1 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:64:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )
                    {
                    match('\\'); 

                    if ( (input.LA(1) >= '0' && input.LA(1) <= '3') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;
                case 2 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:65:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )
                    {
                    match('\\'); 

                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;
                case 3 :
                    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:66:9: '\\\\' ( '0' .. '7' )
                    {
                    match('\\'); 

                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;

            }

        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "OCTAL_ESC"

    // $ANTLR start "UNICODE_ESC"
    public final void mUNICODE_ESC() throws RecognitionException {
        try {
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:71:5: ( '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:71:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
            {
            match('\\'); 

            match('u'); 

            mHEX_DIGIT(); 


            mHEX_DIGIT(); 


            mHEX_DIGIT(); 


            mHEX_DIGIT(); 


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "UNICODE_ESC"

    // $ANTLR start "HEXINT"
    public final void mHEXINT() throws RecognitionException {
        try {
            int _type = HEXINT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:172:8: ( '0x' ( HEX_DIGIT )+ )
            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:172:10: '0x' ( HEX_DIGIT )+
            {
            match("0x"); 



            // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:172:14: ( HEX_DIGIT )+
            int cnt11=0;
            loop11:
            do {
                int alt11=2;
                int LA11_0 = input.LA(1);

                if ( ((LA11_0 >= '0' && LA11_0 <= '9')||(LA11_0 >= 'A' && LA11_0 <= 'F')||(LA11_0 >= 'a' && LA11_0 <= 'f')) ) {
                    alt11=1;
                }


                switch (alt11) {
            	case 1 :
            	    // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'F')||(input.LA(1) >= 'a' && input.LA(1) <= 'f') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt11 >= 1 ) break loop11;
                        EarlyExitException eee =
                            new EarlyExitException(11, input);
                        throw eee;
                }
                cnt11++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "HEXINT"

    public void mTokens() throws RecognitionException {
        // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:8: ( T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | IDT | INT | COMMENT | WS | STRING | CHAR | HEXINT )
        int alt12=26;
        alt12 = dfa12.predict(input);
        switch (alt12) {
            case 1 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:10: T__15
                {
                mT__15(); 


                }
                break;
            case 2 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:16: T__16
                {
                mT__16(); 


                }
                break;
            case 3 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:22: T__17
                {
                mT__17(); 


                }
                break;
            case 4 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:28: T__18
                {
                mT__18(); 


                }
                break;
            case 5 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:34: T__19
                {
                mT__19(); 


                }
                break;
            case 6 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:40: T__20
                {
                mT__20(); 


                }
                break;
            case 7 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:46: T__21
                {
                mT__21(); 


                }
                break;
            case 8 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:52: T__22
                {
                mT__22(); 


                }
                break;
            case 9 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:58: T__23
                {
                mT__23(); 


                }
                break;
            case 10 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:64: T__24
                {
                mT__24(); 


                }
                break;
            case 11 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:70: T__25
                {
                mT__25(); 


                }
                break;
            case 12 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:76: T__26
                {
                mT__26(); 


                }
                break;
            case 13 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:82: T__27
                {
                mT__27(); 


                }
                break;
            case 14 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:88: T__28
                {
                mT__28(); 


                }
                break;
            case 15 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:94: T__29
                {
                mT__29(); 


                }
                break;
            case 16 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:100: T__30
                {
                mT__30(); 


                }
                break;
            case 17 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:106: T__31
                {
                mT__31(); 


                }
                break;
            case 18 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:112: T__32
                {
                mT__32(); 


                }
                break;
            case 19 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:118: T__33
                {
                mT__33(); 


                }
                break;
            case 20 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:124: IDT
                {
                mIDT(); 


                }
                break;
            case 21 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:128: INT
                {
                mINT(); 


                }
                break;
            case 22 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:132: COMMENT
                {
                mCOMMENT(); 


                }
                break;
            case 23 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:140: WS
                {
                mWS(); 


                }
                break;
            case 24 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:143: STRING
                {
                mSTRING(); 


                }
                break;
            case 25 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:150: CHAR
                {
                mCHAR(); 


                }
                break;
            case 26 :
                // C:\\devel\\sidl\\sidl\\grammer\\Sidl.g:1:155: HEXINT
                {
                mHEXINT(); 


                }
                break;

        }

    }


    protected DFA12 dfa12 = new DFA12(this);
    static final String DFA12_eotS =
        "\13\uffff\5\22\3\uffff\1\30\5\uffff\7\22\1\uffff\4\22\1\54\6\22"+
        "\1\uffff\1\22\1\64\1\65\1\66\3\22\3\uffff\1\72\2\22\1\uffff\1\22"+
        "\1\76\1\22\1\uffff\1\100\1\uffff";
    static final String DFA12_eofS =
        "\101\uffff";
    static final String DFA12_minS =
        "\1\11\12\uffff\1\154\1\155\1\165\1\141\1\157\3\uffff\1\170\5\uffff"+
        "\1\141\1\156\1\160\2\164\1\143\1\151\1\uffff\2\163\1\157\1\145\1"+
        "\60\1\153\1\144\1\163\1\164\2\162\1\uffff\1\141\3\60\1\164\1\146"+
        "\1\147\3\uffff\1\60\1\141\1\145\1\uffff\1\143\1\60\1\145\1\uffff"+
        "\1\60\1\uffff";
    static final String DFA12_maxS =
        "\1\175\12\uffff\1\157\1\156\1\165\1\141\1\157\3\uffff\1\170\5\uffff"+
        "\1\141\1\156\1\160\2\164\1\143\1\151\1\uffff\2\163\1\157\1\145\1"+
        "\172\1\153\1\144\1\163\1\164\2\162\1\uffff\1\141\3\172\1\164\1\146"+
        "\1\147\3\uffff\1\172\1\141\1\145\1\uffff\1\143\1\172\1\145\1\uffff"+
        "\1\172\1\uffff";
    static final String DFA12_acceptS =
        "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\5\uffff\1\22"+
        "\1\23\1\24\1\uffff\1\26\1\27\1\30\1\31\1\25\7\uffff\1\32\13\uffff"+
        "\1\17\7\uffff\1\21\1\13\1\14\3\uffff\1\15\3\uffff\1\20\1\uffff\1"+
        "\16";
    static final String DFA12_specialS =
        "\101\uffff}>";
    static final String[] DFA12_transitionS = {
            "\2\25\2\uffff\1\25\22\uffff\1\25\1\uffff\1\26\4\uffff\1\27\1"+
            "\1\1\2\1\3\1\uffff\1\4\1\uffff\1\5\1\24\1\23\11\30\1\uffff\1"+
            "\6\1\uffff\1\7\2\uffff\1\10\32\22\1\11\1\uffff\1\12\1\uffff"+
            "\1\22\1\uffff\2\22\1\13\5\22\1\14\5\22\1\15\1\16\5\22\1\17\4"+
            "\22\1\20\1\uffff\1\21",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\31\2\uffff\1\32",
            "\1\33\1\34",
            "\1\35",
            "\1\36",
            "\1\37",
            "",
            "",
            "",
            "\1\40",
            "",
            "",
            "",
            "",
            "",
            "\1\41",
            "\1\42",
            "\1\43",
            "\1\44",
            "\1\45",
            "\1\46",
            "\1\47",
            "",
            "\1\50",
            "\1\51",
            "\1\52",
            "\1\53",
            "\12\22\7\uffff\32\22\4\uffff\1\22\1\uffff\32\22",
            "\1\55",
            "\1\56",
            "\1\57",
            "\1\60",
            "\1\61",
            "\1\62",
            "",
            "\1\63",
            "\12\22\7\uffff\32\22\4\uffff\1\22\1\uffff\32\22",
            "\12\22\7\uffff\32\22\4\uffff\1\22\1\uffff\32\22",
            "\12\22\7\uffff\32\22\4\uffff\1\22\1\uffff\32\22",
            "\1\67",
            "\1\70",
            "\1\71",
            "",
            "",
            "",
            "\12\22\7\uffff\32\22\4\uffff\1\22\1\uffff\32\22",
            "\1\73",
            "\1\74",
            "",
            "\1\75",
            "\12\22\7\uffff\32\22\4\uffff\1\22\1\uffff\32\22",
            "\1\77",
            "",
            "\12\22\7\uffff\32\22\4\uffff\1\22\1\uffff\32\22",
            ""
    };

    static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS);
    static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS);
    static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS);
    static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS);
    static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS);
    static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS);
    static final short[][] DFA12_transition;

    static {
        int numStates = DFA12_transitionS.length;
        DFA12_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]);
        }
    }

    class DFA12 extends DFA {

        public DFA12(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 12;
            this.eot = DFA12_eot;
            this.eof = DFA12_eof;
            this.min = DFA12_min;
            this.max = DFA12_max;
            this.accept = DFA12_accept;
            this.special = DFA12_special;
            this.transition = DFA12_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | IDT | INT | COMMENT | WS | STRING | CHAR | HEXINT );";
        }
    }
 

}